package br.cnpq.webflowah.ontologia;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
//import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
//import java.util.Map;

import org.mindswap.owl.OWLClass;
import org.mindswap.owl.OWLIndividual;
import org.mindswap.owl.OWLIndividualList;
import org.mindswap.owl.OWLKnowledgeBase;
import org.mindswap.owl.OWLObjectProperty;
import org.mindswap.owl.OWLOntology;
import org.mindswap.owl.vocabulary.RDF;
import org.mindswap.owl.vocabulary.RDFS;
import org.mindswap.query.ValueMap;
import org.mindswap.utils.URIUtils;

import br.cnpq.webflowah.beans.Conceito;

import com.hp.hpl.jena.ontology.DatatypeProperty;
import com.hp.hpl.jena.ontology.ObjectProperty;
import com.hp.hpl.jena.ontology.OntClass;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntProperty;
import com.hp.hpl.jena.ontology.Restriction;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.util.iterator.ExtendedIterator;

public class ConceitoOWL {

	public final static String OWL_URL = "http://localhost/webflowah/1.0/conceitos.owl";

	public final static String OWL_URI = OWL_URL + "#";

	public final static String OWL_CLASS_OBJETO = OWL_URI + "Objeto";

	public final static String OWL_CLASS_TAREFA = OWL_URI + "Tarefa";

	public final static String OWL_PROPERTY_ENVOLVE = OWL_URI + "envolve";

	public final static String OWL_PROPERTY_USADOPOR = OWL_URI + "usadoPor";

	public final static String OWL_PROPERTY_CRIADOPOR = OWL_URI + "criadoPor";

	public final static String OWL_PROPERTY_EXIGIDOPOR = OWL_URI + "exigidoPor";

	public final static String OWL_PROPERTY_GERADOPOR = OWL_URI + "geradoPor";

	public final static String OWL_ANNOTATION_SUBTIPO = OWL_URI + "subTipo";

	public final static String OWL_FILE = Repositorio.CACHE_DIR
			+ "conceitos.owl";

	public final static Conceito objeto = new Conceito("Objeto",
			OWL_CLASS_OBJETO);

	public final static Conceito tarefa = new Conceito("Tarefa",
			OWL_CLASS_TAREFA);

	private static OWLOntology ontology = null;

	// cria o arquivo caso nao exista
	static {
		File file = new File(OWL_FILE);
		if (!file.exists())
			criar();
		else
			abrir();
	}

	private static void criar() {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			ontology = kb.createOntology(URI.create(OWL_URL),
					URI.create(OWL_URL));
			ontology.createClass(URI.create(OWL_CLASS_OBJETO));
			ontology.createClass(URI.create(OWL_CLASS_TAREFA));
			ontology.createObjectProperty(URI.create(OWL_PROPERTY_USADOPOR));
			ontology.createObjectProperty(URI.create(OWL_PROPERTY_CRIADOPOR));
			ontology.createObjectProperty(URI.create(OWL_PROPERTY_EXIGIDOPOR));
			ontology.createObjectProperty(URI.create(OWL_PROPERTY_GERADOPOR));
			ontology.createObjectProperty(URI.create(OWL_PROPERTY_ENVOLVE));

			OntModel ontModel = (OntModel) ontology.getImplementation();
			ontModel.createAnnotationProperty(OWL_ANNOTATION_SUBTIPO);

			ObjectProperty property = ontModel
					.getObjectProperty(OWL_PROPERTY_ENVOLVE);
			property.addDomain(ontModel.getResource(OWL_CLASS_TAREFA));
			property.addRange(ontModel.getResource(OWL_CLASS_OBJETO));

			Restriction restriction = ontModel.createRestriction(property);
			restriction.convertToMinCardinalityRestriction(0);
			restriction.addSubClass(ontModel.getResource(OWL_CLASS_TAREFA));

			property = ontModel.getObjectProperty(OWL_PROPERTY_USADOPOR);
			property.addDomain(ontModel.getResource(OWL_CLASS_OBJETO));
			property.addRange(ontModel.getResource(OWL_CLASS_TAREFA));

			restriction = ontModel.createRestriction(property);
			restriction.convertToMinCardinalityRestriction(0);
			restriction.addSubClass(ontModel.getResource(OWL_CLASS_OBJETO));

			property = ontModel.getObjectProperty(OWL_PROPERTY_CRIADOPOR);
			property.addDomain(ontModel.getResource(OWL_CLASS_OBJETO));
			property.addRange(ontModel.getResource(OWL_CLASS_TAREFA));

			restriction = ontModel.createRestriction(property);
			restriction.convertToMinCardinalityRestriction(0);
			restriction.addSubClass(ontModel.getResource(OWL_CLASS_OBJETO));

			property = ontModel.getObjectProperty(OWL_PROPERTY_EXIGIDOPOR);
			property.addDomain(ontModel.getResource(OWL_CLASS_OBJETO));
			property.addRange(ontModel.getResource(OWL_CLASS_TAREFA));

			restriction = ontModel.createRestriction(property);
			restriction.convertToMinCardinalityRestriction(0);
			restriction.addSubClass(ontModel.getResource(OWL_CLASS_OBJETO));

			property = ontModel.getObjectProperty(OWL_PROPERTY_GERADOPOR);
			property.addDomain(ontModel.getResource(OWL_CLASS_OBJETO));
			property.addRange(ontModel.getResource(OWL_CLASS_TAREFA));

			restriction = ontModel.createRestriction(property);
			restriction.convertToMinCardinalityRestriction(0);
			restriction.addSubClass(ontModel.getResource(OWL_CLASS_OBJETO));

			File file = new File(OWL_FILE);
			kb.getReader().getCache()
					.addCachedFile(ontology.getURI().toString(), file);
			kb.getReader().getCache().updateIndexFile();

			commit();

			// kb.unload(ontology);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void abrir() {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			ontology = kb.read(URI.create(OWL_URI));
			kb.unload(ontology);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}

	// public static Conceito recuperarTipo(URI uri) {
	// try{
	// OWLKnowledgeBase kb = Repositorio.getInstance();
	// OWLOntology ont = kb.load(ontology);
	// OWLIndividual ind = ont.getIndividual(uri);
	// OWLClass classe = ont.getClass(URI.create(OWL_CLASS_OBJETO));
	//
	// if (ind == null) {
	// kb.unload(ont);
	// return null;
	// }
	//
	// Conceito tipo = new Conceito();
	// tipo.setNome(ind.getType().getLocalName());
	// tipo.setURI(ind.getType().getURI().toString());
	// if (ind.getType().isSubClassOf(classe)) {
	// tipo.setTipo(objeto);
	// } else {
	// tipo.setTipo(tarefa);
	// }
	//
	// kb.unload(ont);
	//
	// return tipo;
	// } catch (Exception e) {
	// e.printStackTrace();
	// }
	//
	// return null;
	// }

	public static List<Conceito> recuperarPropriedades(String uri) {
		try {
			List<Conceito> list = new ArrayList<Conceito>();
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.read(uri.substring(0, uri.lastIndexOf("#")));

			OntModel ontModel = (OntModel) ont.getImplementation();
			OntClass ontClass = ontModel.getOntClass(uri);
			OntProperty ontProperty = ontModel.getOntProperty(""
					+ RDFS.subClassOf);

			// tratamento para o tipo rdf:List
			StmtIterator stmtIterator = ontClass.listProperties(ontProperty);
			boolean isList = false;
			while (stmtIterator != null && stmtIterator.hasNext()) {
				Statement stmt = stmtIterator.nextStatement();
				String recurso = "" + stmt.getResource();
				if (recurso.equals(RDF.List.toString()))
					isList = true;
			}

			ExtendedIterator iter = ontClass != null && !isList ? ontClass
					.listDeclaredProperties() : null;
			while (iter != null && iter.hasNext()) {
				Resource r = (Resource) iter.next();
				// verifica se eh DataProperty
				DatatypeProperty datatypeProperty = ontModel
						.getDatatypeProperty(r.getURI());
				if (datatypeProperty != null) {
					Conceito propriedade = new Conceito();
					propriedade.setNome(datatypeProperty.getLocalName());
					propriedade.setURI(datatypeProperty.getURI());
					propriedade.setTipoPrimitivo(true);
					list.add(propriedade);
					continue;
				}
				// verifica se eh ObjectProperty
				ObjectProperty objectProperty = ontModel.getObjectProperty(r
						.getURI());
				if (objectProperty != null) {
					Conceito propriedade = new Conceito();
					propriedade.setNome(objectProperty.getLocalName());
					propriedade.setURI(objectProperty.getURI());
					propriedade.setAnotacao(objectProperty.getRange().getURI());
					propriedade.setTipoPrimitivo(false);
					list.add(propriedade);
				}
			}

			// if (prop.canAs(DatatypeProperty.class)) {
			// Conceito propriedade = new Conceito();
			// propriedade.setNome(prop.getLocalName());
			// propriedade.setURI(prop.getURI());
			// propriedade.setTipoPrimitivo(true);
			// list.add(propriedade);
			// } else if (prop.canAs(ObjectProperty.class)) {
			// Conceito propriedade = new Conceito();
			// propriedade.setNome(prop.getLocalName());
			// propriedade.setURI(prop.getURI());
			// propriedade.setTipoPrimitivo(false);
			// list.add(propriedade);
			// }

			// carregar as propriedades do tipo
			// OntModel ontModel = (OntModel) ont.getImplementation();
			// OntClass ontClass = ontModel.getOntClass(uri);
			// Iterator iter = ontClass != null ?
			// ontClass.listDeclaredProperties() : null;
			// while (iter != null && iter.hasNext()) {
			// String uri1 = "" + iter.next();
			// if (uri1.equals(OWL_PROPERTY_ENVOLVE) ||
			// uri1.equals(OWL_PROPERTY_USADOPOR)) continue;
			// Conceito p = new Conceito();
			// p.setNome(URIUtils.getLocalName(uri1));
			// p.setURI(uri1);
			// list.add(p);
			// }
			//
			kb.unload(ont);

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static List<Conceito> recuperarInstancias(String uri) {
		try {
			List<Conceito> list = new ArrayList<Conceito>();
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.read(uri.substring(0, uri.lastIndexOf("#")));
			// thiago
			// kb.unload(ont);
			OWLClass classe = ont.getClass(URI.create(uri));
			OWLIndividualList indList = classe.getInstances();
			for (int i = 0; indList != null && i < indList.size(); i++) {
				OWLIndividual ind = indList.individualAt(i);
				Conceito valor = new Conceito();
				valor.setNome(ind.getLocalName());
				valor.setURI(ind.getURI().toString());
				list.add(valor);
			}

			kb.unload(ont);

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static Conceito recuperarTipo(URI uri) {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			OWLClass classe = ont.getClass(uri);

			Conceito conceito = new Conceito();
			conceito.setNome(classe.getLocalName());
			conceito.setURI(classe.getURI().toString());
			conceito.setTipo(objeto);
			conceito.setAnotacao(""
					+ classe.getAnnotation(URI.create(OWL_ANNOTATION_SUBTIPO)));

			kb.unload(ont);

			return conceito;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static Conceito recuperar(URI uri) {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			OWLIndividual ind = ont.getIndividual(uri);
			OWLClass classe = ont.getClass(URI.create(OWL_CLASS_OBJETO));

			Conceito conceito = new Conceito();

			if (ind == null) {
				conceito.setNome(URIUtils.getLocalName(uri));
				conceito.setURI(uri.toString());
			} else {
				conceito.setNome(ind.getLocalName());
				conceito.setURI(uri.toString());

				Conceito tipo = new Conceito();
				tipo.setNome(ind.getType().getLocalName());
				tipo.setURI(ind.getType().getURI().toString());
				tipo.setAnotacao(""
						+ ind.getType().getAnnotation(
								URI.create(OWL_ANNOTATION_SUBTIPO)));
				if (ind.getType().isSubClassOf(classe)) {
					tipo.setTipo(objeto);
				} else {
					tipo.setTipo(tarefa);
				}
				// tipo.setObrigatorio("obrigatorio".equals(""+ind.getType().getAnnotation(RDFS.comment)));
				// carregar as propriedades do tipo
				// OntModel ontModel = (OntModel) ont.getImplementation();
				// OntClass ontClass =
				// ontModel.getOntClass(ind.getType().getURI().toString());
				// Iterator iter = ontClass.listDeclaredProperties();
				// while (iter != null && iter.hasNext()) {
				// String uri1 = "" + iter.next();
				// if (uri1.equals(OWL_PROPERTY_ENVOLVE) ||
				// uri1.equals(OWL_PROPERTY_USADOPOR)) continue;
				// Conceito p = new Conceito();
				// p.setNome(URIUtils.getLocalName(uri1));
				// p.setURI(uri1);
				// tipo.addPropriedade(p);
				// }
				conceito.setTipo(tipo);

				OWLObjectProperty prop = ont.getObjectProperty(URI
						.create(OWL_PROPERTY_USADOPOR));
				OWLIndividualList indList = ind.getProperties(prop);

				for (int i = 0; indList != null && i < indList.size(); i++) {
					OWLIndividual j = indList.individualAt(i);
					Conceito associacao = new Conceito();
					associacao.setNome(j.getLocalName());
					associacao.setURI(j.getURI().toString());
					associacao.setTipo(new Conceito(j.getType().getLocalName(),
							j.getType().getURI().toString()));
					associacao.getTipo().setTipo(tarefa);
					associacao.setPredicado(OWL_PROPERTY_USADOPOR);
					conceito.addAssociacao(associacao);
				}

				prop = ont
						.getObjectProperty(URI.create(OWL_PROPERTY_CRIADOPOR));
				indList = ind.getProperties(prop);

				for (int i = 0; indList != null && i < indList.size(); i++) {
					OWLIndividual j = indList.individualAt(i);
					Conceito associacao = new Conceito();
					associacao.setNome(j.getLocalName());
					associacao.setURI(j.getURI().toString());
					associacao.setTipo(new Conceito(j.getType().getLocalName(),
							j.getType().getURI().toString()));
					associacao.getTipo().setTipo(tarefa);
					associacao.setPredicado(OWL_PROPERTY_CRIADOPOR);
					conceito.addAssociacao(associacao);
				}

				prop = ont.getObjectProperty(URI
						.create(OWL_PROPERTY_EXIGIDOPOR));
				indList = ind.getProperties(prop);

				for (int i = 0; indList != null && i < indList.size(); i++) {
					OWLIndividual j = indList.individualAt(i);
					Conceito associacao = new Conceito();
					associacao.setNome(j.getLocalName());
					associacao.setURI(j.getURI().toString());
					associacao.setTipo(new Conceito(j.getType().getLocalName(),
							j.getType().getURI().toString()));
					associacao.getTipo().setTipo(tarefa);
					associacao.setPredicado(OWL_PROPERTY_EXIGIDOPOR);
					conceito.addAssociacao(associacao);
				}

				prop = ont
						.getObjectProperty(URI.create(OWL_PROPERTY_GERADOPOR));
				indList = ind.getProperties(prop);

				for (int i = 0; indList != null && i < indList.size(); i++) {
					OWLIndividual j = indList.individualAt(i);
					Conceito associacao = new Conceito();
					associacao.setNome(j.getLocalName());
					associacao.setURI(j.getURI().toString());
					associacao.setTipo(new Conceito(j.getType().getLocalName(),
							j.getType().getURI().toString()));
					associacao.getTipo().setTipo(tarefa);
					associacao.setPredicado(OWL_PROPERTY_GERADOPOR);
					conceito.addAssociacao(associacao);
				}

				prop = ont.getObjectProperty(URI.create(OWL_PROPERTY_ENVOLVE));
				indList = ind.getProperties(prop);

				for (int i = 0; indList != null && i < indList.size(); i++) {
					OWLIndividual j = indList.individualAt(i);
					Conceito associacao = new Conceito();
					associacao.setNome(j.getLocalName());
					associacao.setURI(j.getURI().toString());
					associacao.setTipo(new Conceito(j.getType().getLocalName(),
							j.getType().getURI().toString()));
					associacao.getTipo().setTipo(objeto);
					associacao.setPredicado(OWL_PROPERTY_ENVOLVE);
					conceito.addAssociacao(associacao);
				}
				// Set key = ind.getProperties().keySet();
				// iter = key.iterator();
				// while (iter != null && iter.hasNext()) {
				// OWLProperty prop1 = (OWLProperty) iter.next();
				// if (OWL_PROPERTY_ENVOLVE.equals(""+prop1.getURI()) ||
				// OWL_PROPERTY_USADOPOR.equals(""+prop1.getURI())) continue;
				// if ("1".equals(""+ind.getProperty((OWLDataProperty) prop1)))
				// {
				// Conceito propriedade = new Conceito();
				// propriedade.setNome(prop1.getLocalName());
				// propriedade.setURI(prop1.getURI().toString());
				// conceito.addPropriedade(propriedade);
				// }
				// }
			}

			kb.unload(ont);

			return conceito;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	// public static OntClass recuperarClasse(Conceito conceito) {
	// try {
	// OWLKnowledgeBase kb = Repositorio.getInstance();
	// OWLOntology ont = kb.load(ontology);
	// OWLClass classe = ont.getClass(URI.create(conceito.getURI()));
	// String uri = null;
	//
	// Set set = classe.getSuperClasses(true);
	// Iterator iter = set.iterator();
	// while (iter.hasNext()) {
	// String str = "" + iter.next();
	// if (!str.equals(OWL_CLASS_OBJETO)) {
	// uri = str;
	// break;
	// }
	// }
	//
	// kb.unload(ont);
	//
	// if (uri == null) return null;
	//
	// ont = kb.read(uri.substring(0, uri.lastIndexOf("#")));
	// OntModel ontModel = (OntModel) ont.getImplementation();
	// kb.unload(ont);
	//
	// return ontModel.getOntClass(uri);
	// } catch (Exception e) {
	// e.printStackTrace();
	// }
	//
	// return null;
	// }

	public static List recuperarObjetos(Conceito tarefa) {
		try {
			List<Conceito> list = null;
			List<String> set = new ArrayList<String>();
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			// OWLDataProperty prop = ont.getDataProperty(RDFS.comment);

			String rdql = "SELECT *\r\n"
					+ "WHERE\r\n"
					+ "(?tarefa rdf:type conceitos:"
					+ tarefa.getNome()
					+ ")\r\n"
					+ "(?objeto rdf:type conceitos:Objeto)\r\n"
					+ "(?tarefa conceitos:envolve ?objeto)\r\n"
					+ "USING\r\n"
					+ "conceitos FOR <http://localhost/webflowah/1.0/conceitos.owl#>";

			List rs = kb.query(rdql);
			for (int i = 0; rs != null && i < rs.size(); i++) {
				ValueMap binding = (ValueMap) rs.get(i);
				OWLIndividual ind = (OWLIndividual) binding.getIndividualValue(
						"objeto").castTo(OWLIndividual.class);
				// remove duplicacao da consulta
				if (set.indexOf(ind.getType().getURI().toString()) < 0) {
					if (list == null)
						list = new ArrayList<Conceito>();
					Conceito c = new Conceito();
					c.setNome(ind.getType().getLocalName());
					c.setURI(ind.getType().getURI().toString());
					c.setAnotacao(""
							+ ind.getType().getAnnotation(
									URI.create(OWL_ANNOTATION_SUBTIPO)));
					c.setTipo(objeto);
					list.add(c);
					set.add(ind.getType().getURI().toString());
				}
			}

			// Iterator iter = rs.iterator();
			// while (iter != null && iter.hasNext()) {
			// ValueMap binding = (ValueMap) iter.next();
			// OWLIndividual ind = (OWLIndividual)
			// binding.getIndividualValue("objeto").castTo(OWLIndividual.class);
			// System.out.println(ind);
			// }

			// OWLClass subClasse = ont.getClass(URI.create(tarefa.getURI()));
			// OWLObjectProperty prop =
			// ont.getObjectProperty(URI.create(OWL_PROPERTY_ENVOLVE));
			// OWLIndividualList indList1 = subClasse.getInstances();
			// Iterator i = indList1 != null ? indList1.iterator() : null;
			//
			// while (i != null && i.hasNext()) {
			// OWLIndividual ind1 = (OWLIndividual) i.next();
			// OWLIndividualList indList2 = ind1.getProperties(prop);
			// Iterator j = indList2 != null ? indList2.iterator() : null;
			// while (j != null && j.hasNext()) {
			// if (list == null) list = new ArrayList<Conceito>();
			// OWLIndividual ind2 = (OWLIndividual) j.next();
			// Conceito c = new Conceito();
			// c.setNome(ind2.getType().getLocalName());
			// c.setURI(ind2.getType().getURI().toString());
			// Conceito tipo = new Conceito();
			// tipo.setNome("Objeto");
			// tipo.setURI(OWL_CLASS_OBJETO);
			// c.setTipo(tipo);
			// list.add(c);
			// }
			// }

			kb.unload(ont);

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static List recuperarEntradas(Conceito tarefa, Conceito objeto,
			List<URI> filtro1, List<URI> filtro2) {
		List<Conceito> list = recuperarParametros(tarefa, objeto,
				OWL_PROPERTY_USADOPOR);
		List<String> set = new ArrayList<String>();
		List<Conceito> descarte = new ArrayList<Conceito>();

		for (int i = 0; list != null && i < list.size(); i++) {
			Conceito conceito = list.get(i);
			URI uri = URI.create(conceito.getURI());
			set.add(conceito.getURI());
			if (filtro1 != null && filtro1.contains(uri))
				descarte.add(conceito);
		}

		for (int i = 0; i < list.size(); i++) {
			List<Conceito> result = recuperarObjetosRelacionados(list.get(i));
			URI uri = URI.create(list.get(i).getURI());
			if (result.size() > 0 && filtro2 != null && !filtro2.contains(uri))
				descarte.add(list.get(i));

			for (int j = 0; j < result.size(); j++) {
				Conceito conceito = (Conceito) result.get(j);
				uri = URI.create(conceito.getURI());
				if (set.indexOf(conceito.getURI()) < 0) {
					list.add(conceito);
					set.add(conceito.getURI());
				}
				if (filtro1 != null && filtro1.contains(uri))
					descarte.add(conceito);
			}
		}

		if (filtro1 != null && filtro1.size() > 0)
			list.removeAll(descarte);

		if (filtro1 == null || filtro1.size() == 0)
			list.removeAll(descarte);

		return list;
	}

	// public static List recuperarEntradas(Conceito tarefa, Conceito objeto) {
	// Map<Object, Conceito> map = new HashMap<Object, Conceito>();
	// List<Conceito> list = recuperarParametros(tarefa, objeto,
	// OWL_PROPERTY_USADOPOR);
	// List<List<Conceito>> combinacoes = new ArrayList<List<Conceito>>();
	// List<Conceito> diff = new ArrayList<Conceito>();
	// diff.addAll(list);
	// if (diff.size() > 0) {
	// combinacoes.add(diff);
	// map.put(diff, new Conceito(null, null));
	// }
	// List<String> set = new ArrayList<String>();
	//
	// for (int i=0; i < list.size(); i++) {
	// Conceito conceito = list.get(i);
	// set.add(conceito.getURI());
	// }
	//
	// // int pos = list.size();
	//
	// for (int i=0; i < list.size(); i++) {
	// List<Conceito> result = recuperarObjetosRelacionados(list.get(i));
	// for (int j=0; j < result.size(); j++) {
	// Conceito conceito = (Conceito) result.get(j);
	// if (set.indexOf(conceito.getURI()) < 0) {
	// list.add(conceito);
	// set.add(conceito.getURI());
	// }
	// }
	//
	// for (int j=0; result.size() > 0 && j < combinacoes.size(); j++) {
	// boolean achou = false;
	// List<Conceito> subset = combinacoes.get(j);
	// diff = new ArrayList<Conceito>();
	//
	// for (int k = 0; k < subset.size(); k++) {
	// if (subset.get(k).getURI().equals(list.get(i).getURI())) {
	// achou = true;
	// } else {
	// diff.add(subset.get(k));
	// }
	// }
	//
	// if (achou) {
	// Conceito conceito = map.get(subset);
	// for (int l=0; l < result.size(); l++) {
	// achou = result.get(l).getURI().equals(conceito.getURI());
	// for (int k=0; k < subset.size(); k++) {
	// if (result.get(l).getURI().equals(subset.get(k).getURI())) {
	// achou = true;
	// break;
	// }
	// }
	// if (!achou) {
	// diff.add(result.get(l));
	// }
	// }
	// combinacoes.add(diff);
	// map.put(diff, list.get(i));
	// }
	// }
	// }
	//
	// // if (pos != list.size()) {
	// // list.add(pos, new Conceito("--- Auxiliares ---", null));
	// // list.add(0, new Conceito("--- Principais ---", null));
	// // }
	//
	// List<Conceito> result = new ArrayList<Conceito>();
	// if (combinacoes.size() > 1) {
	// result.add(new Conceito("----- Principais -----", null));
	// result.addAll(combinacoes.get(0));
	// for (int i=1; i < combinacoes.size(); i++) {
	// result.add(new Conceito("----- Auxiliares -----", null));
	// result.addAll(combinacoes.get(i));
	// }
	// } else {
	// if (combinacoes.size() > 0) {
	// result.addAll(combinacoes.get(0));
	// }
	// }
	//
	//
	// return result;
	// }

	public static List recuperarPreCondicoes(Conceito tarefa, Conceito objeto,
			List<URI> filtro) {
		List<Conceito> list = recuperarParametros(tarefa, objeto,
				OWL_PROPERTY_EXIGIDOPOR);
		List<Conceito> descarte = new ArrayList<Conceito>();

		for (int i = 0; list != null && i < list.size(); i++) {
			Conceito conceito = list.get(i);
			URI uri = URI.create(conceito.getURI());
			if (filtro != null && filtro.contains(uri))
				descarte.add(conceito);
		}

		if (filtro != null && filtro.size() > 0)
			list.removeAll(descarte);

		// List<String> set = new ArrayList<String>();
		// List<Conceito> tarefas = new ArrayList<Conceito>();
		// set.add(tarefa.getURI());
		// tarefas.add(tarefa);

		// List temp = recuperarEntradas(tarefa, objeto);
		// List<Conceito> entradas = new ArrayList<Conceito>();
		//
		// for (int i=0; i < temp.size(); i++) {
		// Conceito entrada = (Conceito) temp.get(i);
		// if ("----- Principais -----".equals(entrada.toString())
		// || "----- Auxiliares -----".equals(entrada.toString())) continue;
		// if (!entradas.contains(entrada))
		// entradas.add(entrada);
		// }
		//
		// for (int i=0; i < entradas.size(); i++) {
		// Conceito entrada = (Conceito) entradas.get(i);
		// List result = recuperarTarefasRelacionadas(objeto, entrada);
		// for (int j=0; j < result.size(); j++) {
		// Conceito conceito = (Conceito) result.get(j);
		// if (set.indexOf(conceito.getURI()) < 0) {
		// tarefas.add(conceito);
		// set.add(conceito.getURI());
		// }
		// }
		// }
		//
		// set.clear();
		// for (int i=0; i < tarefas.size(); i++) {
		// Conceito task = tarefas.get(i);
		// List<Conceito> result = recuperarParametros(task, objeto,
		// OWL_PROPERTY_EXIGIDOPOR);
		// for (int j=0; j < result.size(); j++) {
		// Conceito conceito = result.get(j);
		// if (set.indexOf(conceito.getURI()) < 0) {
		// list.add(conceito);
		// set.add(conceito.getURI());
		// }
		// }
		// }

		return list;
	}

	public static List recuperarSaidas(Conceito tarefa, Conceito objeto,
			List<URI> filtro) {
		List<Conceito> list = recuperarParametros(tarefa, objeto,
				OWL_PROPERTY_CRIADOPOR);
		List<Conceito> descarte = new ArrayList<Conceito>();

		for (int i = 0; list != null && i < list.size(); i++) {
			Conceito conceito = list.get(i);
			URI uri = URI.create(conceito.getURI());
			if (filtro != null && filtro.contains(uri))
				descarte.add(conceito);
		}

		if (filtro != null && filtro.size() > 0)
			list.removeAll(descarte);

		return list;
	}

	public static List recuperarEfeitos(Conceito tarefa, Conceito objeto,
			List<URI> filtro) {
		List<Conceito> list = recuperarParametros(tarefa, objeto,
				OWL_PROPERTY_GERADOPOR);
		List<Conceito> descarte = new ArrayList<Conceito>();

		for (int i = 0; list != null && i < list.size(); i++) {
			Conceito conceito = list.get(i);
			URI uri = URI.create(conceito.getURI());
			if (filtro != null && filtro.contains(uri))
				descarte.add(conceito);
		}

		if (filtro != null && filtro.size() > 0)
			list.removeAll(descarte);

		// List<String> set = new ArrayList<String>();
		// List<Conceito> tarefas = new ArrayList<Conceito>();
		// set.add(tarefa.getURI());
		// tarefas.add(tarefa);
		//
		// List temp = recuperarEntradas(tarefa, objeto);
		// List<Conceito> entradas = new ArrayList<Conceito>();
		//
		// for (int i=0; i < temp.size(); i++) {
		// Conceito entrada = (Conceito) temp.get(i);
		// if ("----- Principais -----".equals(entrada.toString())
		// || "----- Auxiliares -----".equals(entrada.toString())) continue;
		// if (!entradas.contains(entrada))
		// entradas.add(entrada);
		// }
		//
		// for (int i=0; i < entradas.size(); i++) {
		// Conceito entrada = (Conceito) entradas.get(i);
		// List result = recuperarTarefasRelacionadas(objeto, entrada);
		// for (int j=0; j < result.size(); j++) {
		// Conceito conceito = (Conceito) result.get(j);
		// if (set.indexOf(conceito.getURI()) < 0) {
		// tarefas.add(conceito);
		// set.add(conceito.getURI());
		// }
		// }
		// }
		//
		// set.clear();
		// for (int i=0; i < tarefas.size(); i++) {
		// Conceito task = tarefas.get(i);
		// List<Conceito> result = recuperarParametros(task, objeto,
		// OWL_PROPERTY_GERADOPOR);
		// for (int j=0; j < result.size(); j++) {
		// Conceito conceito = result.get(j);
		// if (set.indexOf(conceito.getURI()) < 0) {
		// list.add(conceito);
		// set.add(conceito.getURI());
		// }
		// }
		// }

		return list;
	}

	public static List<Conceito> recuperarObjetosRelacionados(Conceito arg0) {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			List<Conceito> list = new ArrayList<Conceito>();
			List<String> set = new ArrayList<String>();

			String rdql = "SELECT *\r\n"
					+ "WHERE\r\n"
					+ "(?tarefa rdf:type conceitos:Tarefa)\r\n"
					+ "(?objeto1 rdf:type conceitos:"
					+ arg0.getNome()
					+ ")\r\n"
					+ "(?objeto1 conceitos:criadoPor ?tarefa)\r\n"
					+ "(?objeto2 rdf:type conceitos:Objeto)\r\n"
					+ "(?objeto2 conceitos:usadoPor ?tarefa)\r\n"
					+ "USING\r\n"
					+ "conceitos FOR <http://localhost/webflowah/1.0/conceitos.owl#>";

			List rs = kb.query(rdql);

			for (int i = 0; rs != null && i < rs.size(); i++) {
				ValueMap binding = (ValueMap) rs.get(i);
				OWLIndividual ind = (OWLIndividual) binding.getIndividualValue(
						"objeto2").castTo(OWLIndividual.class);
				if (set.indexOf(ind.getType().getURI().toString()) < 0) {
					Conceito conceito = new Conceito();
					conceito.setNome(ind.getType().getLocalName());
					conceito.setURI(ind.getType().getURI().toString());
					conceito.setAnotacao(""
							+ ind.getType().getAnnotation(
									URI.create(OWL_ANNOTATION_SUBTIPO)));
					conceito.setTipo(objeto);
					list.add(conceito);
					set.add(ind.getType().getURI().toString());
				}
			}

			kb.unload(ont);

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static List recuperarTarefasRelacionadas(Conceito arg0, Conceito arg1) {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			List<Conceito> list = new ArrayList<Conceito>();
			List<String> set = new ArrayList<String>();

			String rdql = "SELECT *\r\n"
					+ "WHERE\r\n"
					+ "(?tarefa rdf:type conceitos:Tarefa)\r\n"
					+ "(?objeto1 rdf:type conceitos:"
					+ arg0.getNome()
					+ ")\r\n"
					+ "(?objeto2 rdf:type conceitos:"
					+ arg1.getNome()
					+ ")\r\n"
					+ "(?tarefa conceitos:envolve ?objeto1)\r\n"
					+ "(?objeto2 conceitos:usadoPor ?tarefa)\r\n"
					+ "USING\r\n"
					+ "conceitos FOR <http://localhost/webflowah/1.0/conceitos.owl#>";

			// System.out.println(rdql);

			List rs = kb.query(rdql);

			for (int i = 0; rs != null && i < rs.size(); i++) {
				ValueMap binding = (ValueMap) rs.get(i);
				OWLIndividual ind = (OWLIndividual) binding.getIndividualValue(
						"tarefa").castTo(OWLIndividual.class);
				if (set.indexOf(ind.getType().getURI().toString()) < 0) {
					Conceito conceito = new Conceito();
					conceito.setNome(ind.getType().getLocalName());
					conceito.setURI(ind.getType().getURI().toString());
					conceito.setTipo(tarefa);
					list.add(conceito);
					set.add(ind.getType().getURI().toString());
				}
			}

			kb.unload(ont);

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	private static List<Conceito> recuperarParametros(Conceito tarefa,
			Conceito objeto, String prop) {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			List<Conceito> list = new ArrayList<Conceito>();
			List<String> set = new ArrayList<String>();

			String rdql = "SELECT *\r\n"
					+ "WHERE\r\n"
					+ "(?tarefa rdf:type conceitos:"
					+ tarefa.getNome()
					+ ")\r\n"
					+ "(?tarefa conceitos:envolve ?obj)\r\n"
					+ "(?obj rdf:type conceitos:"
					+ objeto.getNome()
					+ ")\r\n"
					+ "(?objeto rdf:type conceitos:Objeto)\r\n"
					+ "(?objeto conceitos:"
					+ URIUtils.getLocalName(prop)
					+ "?tarefa)\r\n"
					+ "USING\r\n"
					+ "conceitos FOR <http://localhost/webflowah/1.0/conceitos.owl#>";

			List rs = kb.query(rdql);

			// System.out.println(rdql);

			for (int i = 0; rs != null && i < rs.size(); i++) {
				ValueMap binding = (ValueMap) rs.get(i);
				OWLIndividual ind = (OWLIndividual) binding.getIndividualValue(
						"objeto").castTo(OWLIndividual.class);
				if (set.indexOf(ind.getType().getURI().toString()) < 0) {
					Conceito conceito = new Conceito();
					conceito.setNome(ind.getType().getLocalName());
					conceito.setURI(ind.getType().getURI().toString());
					conceito.setAnotacao(""
							+ ind.getType().getAnnotation(
									URI.create(OWL_ANNOTATION_SUBTIPO)));
					conceito.setTipo(objeto);
					list.add(conceito);
					set.add(ind.getType().getURI().toString());
				}
			}

			kb.unload(ont);

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static List recuperarServicos() {
		try {
			List<String> list = null;
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);

			String rdql = "SELECT *\r\n"
					+ "WHERE\r\n"
					+ "(?tarefa rdf:type conceitos:Tarefa)\r\n"
					+ "USING\r\n"
					+ "conceitos FOR <http://localhost/webflowah/1.0/conceitos.owl#>";

			List rs = kb.query(rdql);
			for (int i = 0; rs != null && i < rs.size(); i++) {
				ValueMap binding = (ValueMap) rs.get(i);
				OWLIndividual ind1 = (OWLIndividual) binding
						.getIndividualValue("tarefa").castTo(
								OWLIndividual.class);
				if (list == null)
					list = new ArrayList<String>();
				list.add(ind1.getURI().toString());
			}

			kb.unload(ont);

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	// public static List recuperarServicos(Objetivo objetivo) {
	// try {
	// List<String> list = null;
	// OWLKnowledgeBase kb = Repositorio.getInstance();
	// OWLOntology ont = kb.load(ontology);
	//
	// String rdql = "SELECT *\r\n"
	// + "WHERE\r\n"
	// + "(?tarefa rdf:type conceitos:"
	// + objetivo.getTarefa().getNome()
	// + ")\r\n"
	// + "(?objeto rdf:type conceitos:"
	// + objetivo.getObjeto().getNome()
	// + ")\r\n"
	// + "(?tarefa conceitos:envolve ?objeto)\r\n"
	// + "USING\r\n"
	// + "conceitos FOR <http://localhost/webflowah/1.0/conceitos.owl#>";
	//
	// List rs = kb.query(rdql);
	// for (int i=0; rs != null && i < rs.size(); i++) {
	// ValueMap binding = (ValueMap) rs.get(i);
	// OWLIndividual ind1 = (OWLIndividual)
	// binding.getIndividualValue("tarefa").castTo(OWLIndividual.class);
	// // OWLIndividual ind2 = (OWLIndividual)
	// binding.getIndividualValue("objeto").castTo(OWLIndividual.class);
	// if (list == null) list = new ArrayList<String>();
	// list.add(ind1.getURI().toString());
	// // checar as precondicoes
	// // boolean isTrue = true;
	// // List preCondicoes = objetivo.getPreCondicoes();
	// // for (int j=0; preCondicoes != null && j < preCondicoes.size(); j++) {
	// // Condicao condicao = (Condicao) preCondicoes.get(j);
	// // String uri = condicao.getPredicado().getURI();
	// // OWLDataProperty prop = ont.getDataProperty(URI.create(uri));
	// // OWLDataValue value = ind2.getProperty(prop);
	// // if (condicao.isNegacao())
	// // isTrue &= "0".equals(value.toString());
	// // else
	// // isTrue &= "1".equals(value.toString());
	// // }
	// // if (isTrue) list.add(ind1.getURI().toString());
	// }
	//
	// kb.unload(ont);
	//
	// return list;
	// } catch (Exception e) {
	// e.printStackTrace();
	// }
	//
	// return null;
	// }

	public static List recuperarTodos(String uri) {
		try {
			List<Conceito> list = null;
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			OWLClass classe = ont.getClass(URI.create(uri));

			// recuperar os conceito
			Iterator iter = ont.getSubClasses(classe).iterator();
			while (iter.hasNext()) {
				if (list == null)
					list = new ArrayList<Conceito>();
				OWLClass subClasse = (OWLClass) iter.next();
				Conceito c = new Conceito();
				c.setNome(subClasse.getLocalName());
				c.setURI(subClasse.getURI().toString());
				// c.setObrigatorio("obrigatorio".equals(""+subClasse.getAnnotation(RDFS.comment)));
				Conceito tipo = new Conceito();
				tipo.setURI(classe.getURI().toString());
				tipo.setNome(classe.getLocalName());
				c.setTipo(tipo);
				list.add(c);
			}

			kb.unload(ont);

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static void associar(Conceito conceito) {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			OWLIndividual ind1 = ont
					.getIndividual(URI.create(conceito.getURI()));
			List list = conceito.getAssociacoes();
			for (int i = 0; list != null && i < list.size(); i++) {
				Conceito associacao = (Conceito) list.get(i);
				OWLObjectProperty prop = ont.getObjectProperty(URI
						.create(associacao.getPredicado()));
				OWLIndividual ind2 = ont.getIndividual(URI.create(associacao
						.getURI()));
				if (ind2 == null) {
					OntModel ontModel = (OntModel) ont.getImplementation();
					// URI uri = URI.create(OWL_URI + associacao.getNome());
					OWLClass classe = ont.getClass(URI.create(associacao
							.getTipo().getURI()));
					if (classe == null) {
						classe = ont.createClass(URI.create(associacao
								.getTipo().getURI()));
						if (associacao.getTipo().getAnotacao() != null)
							classe.addAnnotation(
									URI.create(OWL_ANNOTATION_SUBTIPO),
									associacao.getTipo().getAnotacao());
						OntClass ontClass = ontModel.getOntClass(associacao
								.getTipo().getURI());
						ontClass.addSuperClass(ontModel.getResource(associacao
								.getTipo().getTipo().getURI()));
					}
					ind2 = ont.createInstance(classe,
							URI.create(associacao.getURI()));
				}
				ind1.addProperty(prop, ind2);
				// if (ind1.isType(ont.getClass(URI.create(OWL_CLASS_OBJETO))))
				// {
				// OWLObjectProperty prop =
				// ont.getObjectProperty(URI.create(OWL_PROPERTY_USADOPOR));
				// ind1.addProperty(prop, ind2);
				// } else {
				// OWLObjectProperty prop =
				// ont.getObjectProperty(URI.create(OWL_PROPERTY_ENVOLVE));
				// ind1.addProperty(prop, ind2);
				// }
			}
			kb.unload(ont);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void apagar(Conceito conceito) {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			OntModel ontModel = (OntModel) ont.getImplementation();
			Resource resource = ontModel.getResource(conceito.getURI());
			if (resource != null)
				resource.removeProperties();
			kb.unload(ont);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void classificar(Conceito conceito) {
		try {
			OWLKnowledgeBase kb = Repositorio.getInstance();
			OWLOntology ont = kb.load(ontology);
			// apaga a classificacao antiga
			OntModel ontModel = (OntModel) ont.getImplementation();
			Resource resource = ontModel.getResource(conceito.getURI());
			if (resource != null)
				resource.removeProperties();
			// classifica com o novo conceito
			if (conceito.getTipo() != null) {
				OWLClass classe = ont.getClass(URI.create(conceito.getTipo()
						.getURI()));
				if (classe == null) {
					classe = ont.createClass(URI.create(conceito.getTipo()
							.getURI()));
					if (conceito.getTipo().getAnotacao() != null)
						classe.addAnnotation(
								URI.create(OWL_ANNOTATION_SUBTIPO), conceito
										.getTipo().getAnotacao());
					OntClass ontClass = ontModel.getOntClass(conceito.getTipo()
							.getURI());
					ontClass.addSuperClass(ontModel.getResource(conceito
							.getTipo().getTipo().getURI()));
					// ontClass.setComment(conceito.isObrigatorio() ?
					// "obrigatorio" : "opcional", null);
				}
				// OWLIndividual ind = ont.createInstance(classe,
				// URI.create(conceito.getURI().toString()));
				ont.createInstance(classe, URI.create(conceito.getURI()));
				// List list = conceito.getTipo().getPropriedades();
				// for (int i = 0; list != null && i < list.size(); i++) {
				// Conceito propriedade = (Conceito) list.get(i);
				// String uri = propriedade.getURI();
				// OWLDataProperty prop = ont.getDataProperty(URI.create(uri));
				// if (conceito.getPropriedade(uri) != null)
				// ind.addProperty(prop, "1");
				// else
				// ind.addProperty(prop, "0");
				// }
			}
			kb.unload(ont);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// public static void salvar(Conceito conceito) {
	// try {
	// OWLKnowledgeBase kb = Repositorio.getInstance();
	// OWLOntology ont = kb.load(ontology);
	// OntModel ontModel = (OntModel) ont.getImplementation();
	// OntClass ontClass = ontModel.getOntClass(conceito.getURI());
	// if (ontClass == null) {
	// ont.createClass(URI.create(conceito.getURI()));
	// ontClass = ontModel.getOntClass(conceito.getURI());
	// ontClass.addSuperClass(ontModel.getResource(conceito.getTipo().getURI()));
	// }
	// // ontClass.setComment(conceito.isObrigatorio() ? "obrigatorio" :
	// "opcional", null);
	// // remover propriedades
	// // List<String> props = new ArrayList<String>();
	// // Iterator iter = ontClass.listDeclaredProperties();
	// // while (iter != null && iter.hasNext()) {
	// // String uri = "" + iter.next();
	// // if (uri.equals(OWL_PROPERTY_ENVOLVE) ||
	// // uri.equals(OWL_PROPERTY_USADOPOR)) continue;
	// // if (conceito.getPropriedade(uri) == null) {
	// // DatatypeProperty datatypeProperty = ontModel.getDatatypeProperty(uri);
	// // datatypeProperty.remove();
	// // } else {
	// // props.add(uri);
	// // }
	// // }
	// // criar propriedades
	// // List list = conceito.getPropriedades();
	// // for (int i = 0; list != null && i < list.size(); i++) {
	// // Conceito p = (Conceito) list.get(i);
	// // if (props.indexOf(p.getURI()) < 0) {
	// // DatatypeProperty datatypeProperty =
	// ontModel.createDatatypeProperty(p.getURI());
	// // datatypeProperty.addDomain(ontModel.getResource(conceito.getURI()));
	// //
	// datatypeProperty.addRange(ontModel.getResource(XSD.xsdString.toString()));
	// // }
	// // }
	// kb.unload(ont);
	// } catch (Exception e) {
	// e.printStackTrace();
	// }
	// }

	public static void commit() {
		try {
			File file = new File(OWL_FILE);
			FileOutputStream fos = new FileOutputStream(file);
			ontology.write(fos, ontology.getFileURI());
			fos.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// public static void salvarTodos(Map map) {
	// try {
	// OWLKnowledgeBase kb = Repositorio.getInstance();
	// OWLOntology ont = kb.createOntology(URI.create(OWL_URI),
	// URI.create(OWL_URI));
	// ont.createClass(URI.create(OWL_CLASS_OBJETO));
	// ont.createClass(URI.create(OWL_CLASS_TAREFA));
	// ont.createObjectProperty(URI.create(OWL_PROPERTY_USADOPOR));
	// ont.createObjectProperty(URI.create(OWL_PROPERTY_ENVOLVE));
	//
	// OntModel ontModel = (OntModel) ont.getImplementation();
	// ObjectProperty property =
	// ontModel.getObjectProperty(OWL_PROPERTY_ENVOLVE);
	// property.addDomain(ontModel.getResource(OWL_CLASS_TAREFA));
	// property.addRange(ontModel.getResource(OWL_CLASS_OBJETO));
	//
	// Restriction restriction = ontModel.createRestriction(property);
	// restriction.convertToMinCardinalityRestriction(0);
	// restriction.addSubClass(ontModel.getResource(OWL_CLASS_TAREFA));
	//
	// property = ontModel.getObjectProperty(OWL_PROPERTY_USADOPOR);
	// property.addDomain(ontModel.getResource(OWL_CLASS_OBJETO));
	// property.addRange(ontModel.getResource(OWL_CLASS_TAREFA));
	//
	// restriction = ontModel.createRestriction(property);
	// restriction.convertToMinCardinalityRestriction(0);
	// restriction.addSubClass(ontModel.getResource(OWL_CLASS_OBJETO));
	//
	// // Criar as subclasses de Objeto
	// List list = map != null ? (List) map.get(OWL_CLASS_OBJETO) : null;
	// for (int i = 0; list != null && i < list.size(); i++) {
	// String uri = OWL_URI + "#" + list.get(i);
	// ont.createClass(URI.create(uri));
	// OntClass ontClass = ontModel.getOntClass(uri);
	// ontClass.addSuperClass(ontModel.getResource(OWL_CLASS_OBJETO));
	// }
	//
	// // Criar as subclasses de Tarefa
	// list = map != null ? (List) map.get(OWL_CLASS_TAREFA) : null;
	// for (int i = 0; list != null && i < list.size(); i++) {
	// String uri = OWL_URI + "#" + list.get(i);
	// ont.createClass(URI.create(uri));
	// OntClass ontClass = ontModel.getOntClass(uri);
	// ontClass.addSuperClass(ontModel.getResource(OWL_CLASS_TAREFA));
	// }
	//
	// File file = new File(OWL_FILE);
	// // armazena no service.idx
	// if (!file.exists()) {
	// kb.getReader().getCache().addCachedFile(ont.getURI().toString(), file);
	// kb.getReader().getCache().updateIndexFile();
	// }
	// FileOutputStream fos = new FileOutputStream(file);
	// ont.write(fos, ont.getFileURI());
	// fos.close();
	//
	// kb.unload(ont);
	// } catch (FileNotFoundException e) {
	// e.printStackTrace();
	// } catch (IOException e) {
	// e.printStackTrace();
	// }
	// }

}
